package com.shbaiche.bifenba.util;

import android.graphics.Bitmap;
import android.util.Base64;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Created by Administrator on 2018/7/31 0031.
 */

public class StringUtil {
    /**
     * 判断str1和str2是否相同(不区分大小写)
     * @param str1 str1
     * @param str2 str2
     * @return true or false
     */
    public static boolean equalsIgnoreCase(String str1, String str2)
    {
        return str1 != null && str1.equalsIgnoreCase(str2);
    }

    /**
     * 将字符串数组转化为用逗号连接的字符串
     * @param values 字符串数组
     * @return 有字符串数组转化后的字符串
     */
    public static String arrayToString(String[] values)
    {
        StringBuilder result = new StringBuilder();
        String retStr = "";
        if (values != null)
        {
            if (values.length > 0)
            {
                for (String value : values)
                {
                    result.append(value).append(",");
                }

                retStr = result.substring(0, result.length() - 1).toString();
            }
        }

        return retStr;
    }

    /**
     * 验证字符串是否符合email格式
     * @param email 需要验证的字符串
     * @return 如果字符串为空或者为Null返回false， 如果不为空或Null则验证其是否符合email格式，符合则返回true,不符合则返回false
     */
    public static boolean isEmail(String email)
    {
        boolean flag = false;
        if (!isNullOrEmpty(email))
        {
            flag = email.matches("^(\\w+[\\.\\-]?)*?\\w+@(\\w+[\\.\\-]?)*?\\w+\\.\\w+$");

            return flag;
        }
        return flag;
    }

    /**
     * 验证字符串是字符还是字符串还是数字
     * @param str 需要验证的字符串
     * @return 不是数字返回false，是数字就返回true
     */
    public static boolean isNumeric(String str)
    {
        // 需要先判断空字符串，否则会判断出错，因为下面的表达式不能正确识别空字符串
        if (isNullOrEmpty(str))
        {
            return false;
        }

        Pattern pattern = Pattern.compile("[0-9]*");
        Matcher isNum = pattern.matcher(str);
        return isNum.matches();
    }

    /**
     * 验证字符串是否符合手机号格式
     * @param str 需要验证的字符串
     * @return 不是手机号返回false，是手机号就返回true
     */
    public static boolean isMobile(String str)
    {
        // Pattern pattern = Pattern.compile("(13[0-9]|15[0-9]|14[57]|18[0-9]|17[07]|)\\d{8}");
        // Matcher isMobile = pattern.matcher(str);
        // return isMobile.matches();

        boolean boo = false;
        if (!isNullOrEmpty(str) && str.length() == 11)
        {
            boo = true;
        }

        return boo;
    }

    /**
     * 验证字符串是否符合身份证号格式<BR>
     * @param str 需要验证的字符串
     * @return 不是身份证号返回false，是身份证号就返回true
     */
    public static boolean isCertNo(String str)
    {
        Pattern pattern = Pattern.compile("(\\d{14}[0-9a-zA-Z])|(\\d{17}[0-9a-zA-Z])");
        Matcher isMobile = pattern.matcher(str);
        return isMobile.matches();
    }

    /**
     * 判断是否为null
     * @param str str
     * @return true or false
     */
    public static boolean isNull(String str)
    {
        return str == null;
    }

    /**
     * 判断是否为null或空值
     * @param str str
     * @return true or false
     */
    public static boolean isNullOrEmpty(String str)
    {
        return str == null || str.trim().length() < 1;
    }

    /**
     * <pre>
     * 需要隐藏手机号，变成类似123****4567.
     * </pre>
     * @param phone
     * @return
     */
    public static String phoneToShiel(String phone)
    {
        return phone.replaceAll("(?<=\\G.{3})(\\d{1})(\\d{3})", "****");
    }

    public static Date parseDateByPattern(String dateStr,String dateFormat){
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        try {
            return sdf.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String formatDate(String pattern, Date date)
    {
        if (!isNullOrEmpty(pattern) && date != null)
        {
            try {
                SimpleDateFormat df = new SimpleDateFormat(pattern, Locale.getDefault());
                return df.format(date);
            }catch (Exception e){
                e.printStackTrace();

                return "";
            }

        }
        else
        {
            return "";
        }
    }

    public static String getTodayOrYesterday(long date) {//date 是存储的时间戳
        //所在时区时8，系统初始时间是1970-01-01 80:00:00，注意是从八点开始，计算的时候要加回去
        int offSet = Calendar.getInstance().getTimeZone().getRawOffset();
        long today = (System.currentTimeMillis()+offSet)/86400000;
        long start = (date+offSet)/86400000;
        long intervalTime = start - today;
        //-2:前天,-1：昨天,0：今天,1：明天,2：后天
        Date da = new Date(date);
        String strDes="";
        if(intervalTime==0){
            strDes = "今天"+formatDate("HH:mm",da);//今天
        }else if(intervalTime==1){
            strDes =  "明天"+formatDate("HH:mm",da);//昨天
        }else if(intervalTime==2){
            strDes =  "后天"+formatDate("HH:mm",da);//昨天
        }else if(intervalTime==-1){
            strDes =  "昨天"+formatDate("HH:mm",da);//昨天
        }else{
            strDes=formatDate("MM-dd HH:mm",da);//直接显示时间
        }
        return strDes;
    }

    /**
     * 将长时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss
     *
     * @param strDate
     * @return
     */
    public static Date strToDateLong(String strDate) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        ParsePosition pos = new ParsePosition(0);
        Date strtodate = formatter.parse(strDate, pos);
        return strtodate;
    }

    private final static long minute = 60 * 1000;// 1分钟
    private final static long hour = 60 * minute;// 1小时
    private final static long day = 24 * hour;// 1天
    private final static long month = 31 * day;// 月
    private final static long year = 12 * month;// 年

    /**
     * 返回文字描述的日期
     *
     * @param date
     * @return
     */
    public static String getTimeFormatText(Date date) {
        if (date == null) {
            return null;
        }
        long diff = new Date().getTime() - date.getTime();
        long r = 0;
        if (diff > year) {
            r = (diff / year);
            return r + "年前";
        }
        if (diff > month) {
            r = (diff / month);
            return r + "个月前";
        }
        if (diff > day) {
            r = (diff / day);
            return r + "天前";
        }
        if (diff > hour) {
            r = (diff / hour);
            return r + "个小时前";
        }
        if (diff > minute) {
            r = (diff / minute);
            return r + "分钟前";
        }
        return "刚刚";
    }

    /**
     * bitmap转为base64
     * @param bitmap
     * @return
     */
    public static String bitmapToBase64(Bitmap bitmap) {

        String result = null;
        ByteArrayOutputStream baos = null;
        try {
            if (bitmap != null) {
                baos = new ByteArrayOutputStream();
                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);

                baos.flush();
                baos.close();

                byte[] bitmapBytes = baos.toByteArray();
                result = Base64.encodeToString(bitmapBytes, Base64.DEFAULT);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.flush();
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

}
